/**
 * 模板服务层
 * 提供模板管理的业务逻辑，连接存储层和UI层
 */

import { 
  DocumentTemplate,
  CreateTemplateInput,
  UpdateTemplateInput,
  TemplateFilters,
  TemplateStats,
  TemplateSearchResult,
  TemplateOperationResult,
  TemplateImportResult,
  TEMPLATE_STORAGE_KEYS
} from '../../types/template'
import { Content, ContentType, ContentStatus, generateId } from '../../types/document'
import { LocalStorageTemplateAdapter } from '../storage/templateStorageAdapter'
import { getAllBuiltInTemplates } from './builtInTemplates'

/**
 * 模板服务类
 */
export class TemplateService {
  private storageAdapter: LocalStorageTemplateAdapter
  private initialized: boolean = false

  constructor() {
    this.storageAdapter = new LocalStorageTemplateAdapter()
  }

  /**
   * 初始化服务
   */
  async initialize(): Promise<TemplateOperationResult<void>> {
    try {
      if (this.initialized) {
        return { success: true, data: undefined }
      }

      // 初始化内置模板
      const builtInTemplates = getAllBuiltInTemplates()
      const initResult = await this.storageAdapter.initializeBuiltInTemplates(builtInTemplates)
      
      if (!initResult.ok) {
        return { 
          success: false, 
          error: `初始化内置模板失败: ${initResult.error.message}` 
        }
      }

      this.initialized = true
      console.log('[模板服务] 服务初始化完成，内置模板加载成功')
      
      return { success: true, data: undefined }
    } catch (error) {
      console.error('[模板服务] 初始化失败:', error)
      return { 
        success: false, 
        error: `服务初始化失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 创建新模板
   */
  async createTemplate(input: CreateTemplateInput): Promise<TemplateOperationResult<string>> {
    try {
      // 验证输入
      const validation = this.validateTemplateInput(input)
      if (!validation.success) {
        return validation
      }

      const now = new Date()
      const templateId = `template-${generateId()}`
      
      const template: DocumentTemplate = {
        id: templateId,
        name: input.name,
        description: input.description,
        category: input.category,
        type: input.type,
        contentType: input.contentType,
        content: input.content,
        metadata: {
          ...input.metadata,
          version: '1.0'
        },
        isBuiltIn: false,
        createdAt: now,
        updatedAt: now,
        usageCount: 0,
        tags: input.tags || []
      }

      const saveResult = await this.storageAdapter.saveTemplate(template)
      
      if (!saveResult.ok) {
        return { 
          success: false, 
          error: `保存模板失败: ${saveResult.error.message}` 
        }
      }

      console.log('[模板服务] 模板创建成功:', template.name)
      return { success: true, data: templateId }
    } catch (error) {
      console.error('[模板服务] 创建模板失败:', error)
      return { 
        success: false, 
        error: `创建模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 获取模板
   */
  async getTemplate(id: string): Promise<TemplateOperationResult<DocumentTemplate | null>> {
    try {
      const result = await this.storageAdapter.getTemplate(id)
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `获取模板失败: ${result.error.message}` 
        }
      }

      return { success: true, data: result.data }
    } catch (error) {
      console.error('[模板服务] 获取模板失败:', error)
      return { 
        success: false, 
        error: `获取模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 更新模板
   */
  async updateTemplate(id: string, input: UpdateTemplateInput): Promise<TemplateOperationResult<void>> {
    try {
      // 检查模板是否存在
      const existingResult = await this.getTemplate(id)
      if (!existingResult.success || !existingResult.data) {
        return { success: false, error: '模板不存在' }
      }

      // 检查是否为内置模板
      if (existingResult.data.isBuiltIn) {
        return { success: false, error: '不能修改内置模板' }
      }

      const updateResult = await this.storageAdapter.updateTemplate(id, {
        ...input,
        metadata: input.metadata ? {
          ...existingResult.data.metadata,
          ...input.metadata
        } : existingResult.data.metadata
      })
      
      if (!updateResult.ok) {
        return { 
          success: false, 
          error: `更新模板失败: ${updateResult.error.message}` 
        }
      }

      console.log('[模板服务] 模板更新成功:', id)
      return { success: true, data: undefined }
    } catch (error) {
      console.error('[模板服务] 更新模板失败:', error)
      return { 
        success: false, 
        error: `更新模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 删除模板
   */
  async deleteTemplate(id: string): Promise<TemplateOperationResult<void>> {
    try {
      const deleteResult = await this.storageAdapter.deleteTemplate(id)
      
      if (!deleteResult.ok) {
        return { 
          success: false, 
          error: `删除模板失败: ${deleteResult.error.message}` 
        }
      }

      console.log('[模板服务] 模板删除成功:', id)
      return { success: true, data: undefined }
    } catch (error) {
      console.error('[模板服务] 删除模板失败:', error)
      return { 
        success: false, 
        error: `删除模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 获取所有模板
   */
  async getAllTemplates(): Promise<TemplateOperationResult<DocumentTemplate[]>> {
    try {
      const result = await this.storageAdapter.getAllTemplates()
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `获取模板列表失败: ${result.error.message}` 
        }
      }

      // 按创建时间排序，内置模板在前
      const sortedTemplates = result.data.sort((a, b) => {
        if (a.isBuiltIn && !b.isBuiltIn) return -1
        if (!a.isBuiltIn && b.isBuiltIn) return 1
        return b.createdAt.getTime() - a.createdAt.getTime()
      })

      return { success: true, data: sortedTemplates }
    } catch (error) {
      console.error('[模板服务] 获取模板列表失败:', error)
      return { 
        success: false, 
        error: `获取模板列表失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 搜索模板
   */
  async searchTemplates(
    query: string = '', 
    filters?: TemplateFilters
  ): Promise<TemplateOperationResult<TemplateSearchResult>> {
    try {
      const result = await this.storageAdapter.searchTemplates(query, filters)
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `搜索模板失败: ${result.error.message}` 
        }
      }

      // 按相关性和使用次数排序
      const sortedTemplates = result.data.sort((a, b) => {
        // 内置模板优先
        if (a.isBuiltIn && !b.isBuiltIn) return -1
        if (!a.isBuiltIn && b.isBuiltIn) return 1
        
        // 然后按使用次数排序
        if (a.usageCount !== b.usageCount) {
          return b.usageCount - a.usageCount
        }
        
        // 最后按创建时间排序
        return b.createdAt.getTime() - a.createdAt.getTime()
      })

      const searchResult: TemplateSearchResult = {
        templates: sortedTemplates,
        total: sortedTemplates.length,
        hasMore: false, // 目前不支持分页
        filters
      }

      return { success: true, data: searchResult }
    } catch (error) {
      console.error('[模板服务] 搜索模板失败:', error)
      return { 
        success: false, 
        error: `搜索模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 从模板创建文档
   */
  async createDocumentFromTemplate(
    templateId: string, 
    customTitle?: string
  ): Promise<TemplateOperationResult<Content>> {
    try {
      console.log('[模板服务] 开始从模板创建文档, templateId:', templateId, 'customTitle:', customTitle)
      
      // 获取模板
      const templateResult = await this.getTemplate(templateId)
      console.log('[模板服务] 获取模板结果:', templateResult)
      
      if (!templateResult.success || !templateResult.data) {
        console.error('[模板服务] 模板不存在或获取失败:', templateId)
        return { success: false, error: '模板不存在' }
      }

      const template = templateResult.data
      console.log('[模板服务] 成功获取模板:', template)
      
      const now = new Date()
      
      // 增加使用次数
      console.log('[模板服务] 增加模板使用次数...')
      await this.incrementUsage(templateId)

      // 创建文档内容
      console.log('[模板服务] 创建文档内容...')
      const documentContent: Content = {
        id: generateId(),
        type: template.contentType,
        title: customTitle || template.name,
        description: template.description,
        createdAt: now,
        updatedAt: now,
        status: ContentStatus.DRAFT,
        tags: [...template.tags],
        metadata: {
          fromTemplate: templateId,
          templateName: template.name,
          templateVersion: template.metadata.version
        },
        data: {
          content: template.content,
          wordCount: this.calculateWordCount(template.content)
        }
      } as Content

      console.log('[模板服务] 创建的文档内容:', documentContent)
      console.log('[模板服务] 从模板创建文档成功:', template.name)
      return { success: true, data: documentContent }
    } catch (error) {
      console.error('[模板服务] 从模板创建文档失败:', error)
      console.error('[模板服务] 错误堆栈:', error instanceof Error ? error.stack : '无堆栈信息')
      return { 
        success: false, 
        error: `从模板创建文档失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 将文档保存为模板
   */
  async saveAsTemplate(
    content: Content, 
    templateInfo: Partial<CreateTemplateInput>
  ): Promise<TemplateOperationResult<string>> {
    try {
      if (content.type !== ContentType.TEXT_DOCUMENT) {
        return { success: false, error: '目前只支持将文本文档保存为模板' }
      }

      const input: CreateTemplateInput = {
        name: templateInfo.name || content.title,
        description: templateInfo.description || content.description,
        category: templateInfo.category!,
        type: templateInfo.type!,
        contentType: content.type,
        content: (content.data as any).content || '',
        metadata: {
          author: templateInfo.metadata?.author || '用户',
          difficulty: templateInfo.metadata?.difficulty || 'medium',
          language: templateInfo.metadata?.language || 'zh-CN',
          estimatedLength: this.calculateWordCount((content.data as any).content || '')
        },
        tags: templateInfo.tags || content.tags || []
      }

      return await this.createTemplate(input)
    } catch (error) {
      console.error('[模板服务] 保存为模板失败:', error)
      return { 
        success: false, 
        error: `保存为模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 获取模板统计信息
   */
  async getTemplateStats(): Promise<TemplateOperationResult<TemplateStats>> {
    try {
      const result = await this.storageAdapter.getTemplateStats()
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `获取模板统计失败: ${result.error.message}` 
        }
      }

      return { success: true, data: result.data }
    } catch (error) {
      console.error('[模板服务] 获取模板统计失败:', error)
      return { 
        success: false, 
        error: `获取模板统计失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 增加模板使用次数
   */
  async incrementUsage(templateId: string): Promise<TemplateOperationResult<void>> {
    try {
      const result = await this.storageAdapter.incrementUsageCount(templateId)
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `更新使用次数失败: ${result.error.message}` 
        }
      }

      return { success: true, data: undefined }
    } catch (error) {
      console.error('[模板服务] 更新使用次数失败:', error)
      return { 
        success: false, 
        error: `更新使用次数失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 导出模板
   */
  async exportTemplate(templateId: string): Promise<TemplateOperationResult<string>> {
    try {
      const result = await this.storageAdapter.exportTemplates([templateId])
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `导出模板失败: ${result.error.message}` 
        }
      }

      return { success: true, data: result.data }
    } catch (error) {
      console.error('[模板服务] 导出模板失败:', error)
      return { 
        success: false, 
        error: `导出模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 批量导出模板
   */
  async exportTemplates(templateIds: string[]): Promise<TemplateOperationResult<string>> {
    try {
      const result = await this.storageAdapter.exportTemplates(templateIds)
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `批量导出模板失败: ${result.error.message}` 
        }
      }

      return { success: true, data: result.data }
    } catch (error) {
      console.error('[模板服务] 批量导出模板失败:', error)
      return { 
        success: false, 
        error: `批量导出模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  /**
   * 导入模板
   */
  async importTemplates(jsonData: string): Promise<TemplateOperationResult<TemplateImportResult>> {
    try {
      const result = await this.storageAdapter.importTemplates(jsonData)
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `导入模板失败: ${result.error.message}` 
        }
      }

      const importResult: TemplateImportResult = {
        success: true,
        templateIds: result.data,
        errors: [],
        warnings: []
      }

      console.log('[模板服务] 模板导入成功，导入数量:', result.data.length)
      return { success: true, data: importResult }
    } catch (error) {
      console.error('[模板服务] 导入模板失败:', error)
      
      const importResult: TemplateImportResult = {
        success: false,
        templateIds: [],
        errors: [error instanceof Error ? error.message : '未知错误'],
        warnings: []
      }
      
      return { success: true, data: importResult }
    }
  }

  /**
   * 清空所有模板（开发调试用）
   */
  async clearAllTemplates(): Promise<TemplateOperationResult<void>> {
    try {
      const result = await this.storageAdapter.clearAllTemplates()
      
      if (!result.ok) {
        return { 
          success: false, 
          error: `清空模板失败: ${result.error.message}` 
        }
      }

      // 重新初始化内置模板
      this.initialized = false
      await this.initialize()

      console.log('[模板服务] 所有模板已清空并重新初始化')
      return { success: true, data: undefined }
    } catch (error) {
      console.error('[模板服务] 清空模板失败:', error)
      return { 
        success: false, 
        error: `清空模板失败: ${error instanceof Error ? error.message : '未知错误'}` 
      }
    }
  }

  // 私有方法

  /**
   * 验证模板输入
   */
  private validateTemplateInput(input: CreateTemplateInput): TemplateOperationResult<void> {
    const errors: string[] = []

    if (!input.name || input.name.trim().length === 0) {
      errors.push('模板名称不能为空')
    }

    if (input.name && input.name.length > 100) {
      errors.push('模板名称不能超过100个字符')
    }

    if (!input.content || input.content.trim().length === 0) {
      errors.push('模板内容不能为空')
    }

    if (input.content && input.content.length > 50000) {
      errors.push('模板内容不能超过50000个字符')
    }

    if (!input.category) {
      errors.push('必须选择模板分类')
    }

    if (!input.type) {
      errors.push('必须选择模板类型')
    }

    if (!input.contentType) {
      errors.push('必须指定内容类型')
    }

    if (input.tags && input.tags.length > 10) {
      errors.push('标签数量不能超过10个')
    }

    if (errors.length > 0) {
      return { success: false, error: errors.join('; ') }
    }

    return { success: true, data: undefined }
  }

  /**
   * 计算字数
   */
  private calculateWordCount(content: string): number {
    if (!content) return 0
    
    // 简单的中文字数统计
    return content.replace(/\s/g, '').length
  }
}

// 导出单例实例
export const templateService = new TemplateService()